package Applikationslogik;

import Datenbank.*;
import java.rmi.*;
import java.sql.*;
import java.util.*;
import java.util.Date;


/**
 *
 * @author Rene & Daniel
 */
public class VerwaltungImpl extends java.rmi.server.UnicastRemoteObject implements Verwaltung {

    private PersonMapper peMapper;
    private KalenderMapper kaMapper;
    private KategorieMapper ktMapper;
    private KalendereintragMapper keMapper;
    private WiederholungMapper whMapper;
    private TerminMapper teMapper;
    private AlarmMapper alMapper;


    /**
     *
     * @param personMapper
     * @param kalenderMapper
     * @param kategorieMapper
     * @param kalendereintragMapper
     * @param wiederholungMapper
     * @param terminMapper
     * @param alarmMapper
     * @throws RemoteException
     */
    public VerwaltungImpl( PersonMapper personMapper, KalenderMapper kalenderMapper, KategorieMapper kategorieMapper, KalendereintragMapper kalendereintragMapper, WiederholungMapper wiederholungMapper, TerminMapper terminMapper, AlarmMapper alarmMapper) throws RemoteException {

       super();
        this.peMapper = personMapper;
        this.kaMapper = kalenderMapper;
        this.ktMapper = kategorieMapper;
        this.keMapper = kalendereintragMapper;
        this.whMapper = wiederholungMapper;
        this.teMapper = terminMapper;
        this.alMapper = alarmMapper;
    }


   /**
    *
    * @param person_id
    * @param raum
    * @param nachname
    * @param vorname
    * @param telefon
    * @param ist_admin
    * @param email
    * @return
    * @throws RemoteException
    */
   public Person createPerson(int person_id, int raum, String nachname, String vorname, int telefon, boolean ist_admin, String email) throws RemoteException {

        Person pe = new PersonImpl();
        pe.set_person_id(2); // wird überschrieben wenn Datenbank schreibt
        pe.set_raum(raum);
        pe.set_nachname(nachname);
        pe.set_vorname(vorname);
        pe.set_telefon(telefon);
        pe.set_ist_admin(ist_admin);
        pe.set_email(email);

      if (!pe.get_nachname().isEmpty() && !pe.get_vorname().isEmpty() && !pe.get_email().isEmpty() )
        return peMapper.insert(pe); //Speichert die Person


    else {
        throw new RemoteException("Bitte Eingaben überprüfen.");
        }
    }

   /**
    *
    * @param x
    * @return
    * @throws RemoteException
    */
   public Person updatePerson(Person x) throws RemoteException {


      if (!x.get_nachname().isEmpty() && !x.get_vorname().isEmpty() && !x.get_email().isEmpty() )
        return peMapper.update(x); //Speichert die Person

    else {
        throw new RemoteException("Bitte Eingaben überprüfen.");

        }
    }

    /**
 *
 * @param id
 * @return
 * @throws RemoteException
 */
    public Person getPerson_byid(int id) throws RemoteException {

    return peMapper.findbyid(id);
}

    /**
 *
 * @return
 * @throws RemoteException
 */
    public Vector <Person> getAllPerson()throws RemoteException  {

            return peMapper.findall_person();
        }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector <Person> getAllPerson_ohne_uebergebene_person(Person x) throws RemoteException {

        return peMapper.findall_person_ohne_uebergebene_person(x.get_person_id());
    }

    /**
     *
     * @param x
     * @param y
     * @throws RemoteException
     */
    public void deletePerson(Person x, Person y)throws RemoteException  {
            System.out.println("------------------deletePerson---------------");
            System.out.println(x.get_voller_name() + y.get_voller_name());
            if(ktMapper.check_kategorie_exists_byperson(x) || kaMapper.check_kalender_exists_byperson(x))
                throw new RemoteException("Es existieren noch Kalender oder Kategorien. Bitte überprüfen.");
            else
                peMapper.delete(x);

        }

    /**
     *
     * @param kalender_id
     * @param bezeichnung
     * @param besitzer
     * @param lesen
     * @param schreiben
     * @return
     * @throws RemoteException
     */
    public Kalender createKalender(int kalender_id, String bezeichnung, int besitzer, List<Integer> lesen, List<Integer> schreiben) throws RemoteException {

            Kalender ka = new KalenderImpl();
            ka.set_kalender_id(2); // wird überschrieben wenn Datenbank schreibt
            ka.set_bezeichnung(bezeichnung);
            ka.set_besitzer(besitzer);
            ka.set_berechtigung_lesen(lesen);
            ka.set_berechtigung_schreiben(schreiben);

          if (!ka.get_bezeichnung().isEmpty())
            return kaMapper.insert(ka); //Speichert den Kalender


          else {
            throw new RemoteException("Bitte Eingaben überprüfen.");

            }
    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Kalender updateKalender(Kalender x) throws RemoteException {
            System.out.println(x.get_bezeichnung());

          if (!x.get_bezeichnung().isEmpty() )

              return kaMapper.update(x); //Speichert den Kalender

        else {
            throw new RemoteException("Bitte Eingaben überprüfen.");

            }
        }

    /**
     *
     * @param id
     * @return
     * @throws RemoteException
     */
    public Kalender getKalender_byid(int id) throws RemoteException {

        return kaMapper.findbyid(id);
    }

    /**
     *
     * @param id
     * @return
     * @throws RemoteException
     */
    public Wiederholung getWiederholung_byid(int id) throws RemoteException {

        return whMapper.findbyid(id);
    }

    /**
     *
     * @param kategorie_id
     * @param name
     * @param person_id
     * @return
     * @throws RemoteException
     */
    public Kategorie createKategorie(int kategorie_id, String name, int person_id) throws RemoteException {

            Kategorie kt = new KategorieImpl();
            kt.set_kategorie_id(2); // wird überschrieben wenn Datenbank schreibt
            kt.set_name(name);
            kt.set_person_id(person_id);

          if (!kt.get_name().isEmpty() )
            return ktMapper.insert(kt); //Speichert die Kategorie


        else {
            throw new RemoteException("Bitte Eingaben überprüfen.");

            }
        }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Kategorie updateKategorie(Kategorie x) throws RemoteException {


          if (!x.get_name().isEmpty())
            return ktMapper.update(x); //Speichert die Person

        else {
            throw new RemoteException("Bitte Eingaben überprüfen.");

            }
        }

    /**
     *
     * @param id
     * @return
     * @throws RemoteException
     */
    public Kategorie getKategorie_byid(int id) throws RemoteException {

        return ktMapper.findbyid(id);

        }

    /**
     *
     * @param person_id
     * @return
     * @throws RemoteException
     */
    public Vector getallKategorie_byPerson(int person_id) throws RemoteException {

        return ktMapper.findallKategorie_byPerson(person_id);

        }

    /**
     *
     * @return
     */
    public Vector <Kategorie> get_all_Kategorie() {

        return ktMapper.findallKategorie();

        }

    /**
     *
     * @param start
     * @param ende
     * @param ort
     * @param beschreibung
     * @param kategorie_id
     * @param erinnerung
     * @param person_id
     * @param eintrag_id
     * @param kalender_id
     * @return
     * @throws RemoteException
     */
    public Kalendereintrag createKalendereintrag(Timestamp start, Timestamp ende, String ort, String beschreibung, int kategorie_id, int erinnerung, int person_id, int eintrag_id, int kalender_id) throws RemoteException {

            Kalendereintrag ke = new KalendereintragImpl();
            ke.set_kalender_id(kalender_id);
            ke.set_start(start);
            ke.set_ende(ende);
            ke.set_ort(ort);
            ke.set_beschreibung(beschreibung);
            ke.set_kategorie(kategorie_id);
            ke.set_erinnerung(erinnerung);
            ke.set_erstelltvon(person_id);
            ke.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt

                  // Überprüfung ob Ort ausgefüllt wurde
                  if (ke.get_ort().isEmpty())
                  throw new RemoteException("Bitte Ort überprüfen.");

                  // Überprüfung ob Beschreibung ausgefüllt wurde
                  else if (ke.get_beschreibung().isEmpty())
                  throw new RemoteException("Bitte Beschreibung überprüfen.");

                  // Überprüfung ob START Datum vor END Datum liegt
                  else if (ke.get_start().getTime() >= ke.get_ende().getTime())
                  throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");

                  // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                  else if (keMapper.check_datum_available(ke.get_start(), ke.get_ende(), ke.get_kalender_id()))
                  throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");

          // Falls keine Fehler vorliegen, wird der Eintrag in der Datenbank abgespeichert
          else {
             return keMapper.insert(ke); //Speichert den Kalendereintrag
            }
        }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Kalendereintrag updateKalendereintrag(Kalendereintrag x) throws RemoteException {

                  // Überprüfung ob Ort ausgefüllt wurde
                  if (x.get_ort().isEmpty())
                  throw new RemoteException("Bitte Ort überprüfen.");

                  // Überprüfung ob Beschreibung ausgefüllt wurde
                  else if (x.get_beschreibung().isEmpty())
                  throw new RemoteException("Bitte Beschreibung überprüfen.");

                  // Überprüfung ob START Datum vor END Datum liegt
                  else if (x.get_start().getTime() >= x.get_ende().getTime())
                  throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");

                  // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                  else if (keMapper.check_datum_available_at_update(x.get_start(), x.get_ende(), x.get_kalender_id(), x.get_eintrag_id()))
                  throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");

          // Falls keine Fehler vorliegen, wird der Eintrag in der Datenbank abgespeichert
          else {
             return keMapper.update(x); //Speichert den Kalendereintrag
            }
        }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteKalendereintrag(Kalendereintrag x) throws RemoteException {

            keMapper.delete(x); //Löscht den Kalendereintrag
        }

    /**
     *
     * @param start
     * @param ende
     * @param ort
     * @param beschreibung
     * @param kategorie_id
     * @param erinnerung
     * @param person_id
     * @param eintrag_id
     * @param kalender_id
     * @param anzahl
     * @param serienmuster
     * @throws RemoteException
     */
    public void createWiederholung(Timestamp start, Timestamp ende, String ort, String beschreibung, int kategorie_id, int erinnerung, int person_id, int eintrag_id, int kalender_id, int anzahl, char serienmuster) throws RemoteException {

            int highest_wh_id = whMapper.get_highest_wh_id() + 1; // es wird nach der nächsten wiederholungs_id gesucht und diese dann +1 gesetzt

            // Debug
            System.out.println("Höchste Wiederholung ID in der Datenbank: " + highest_wh_id);

            switch(serienmuster){
                case 't' :                                                          // bei t wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Wiederholung wh_start = new WiederholungImpl();
                            wh_start.set_kalender_id(kalender_id);
                            wh_start.set_start(start);
                            wh_start.set_ende(ende);
                            wh_start.set_ort(ort);
                            wh_start.set_beschreibung(beschreibung);
                            wh_start.set_kategorie(kategorie_id);
                            wh_start.set_erinnerung(erinnerung);
                            wh_start.set_erstelltvon(person_id);
                            wh_start.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            wh_start.set_wiederholung_id(highest_wh_id);
                            wh_start.set_serienmuster(serienmuster);
                            wh_start.set_anzahl(anzahl);

                            if (wh_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start.get_start().getTime() >= wh_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh_start.get_start(), wh_start.get_ende(), wh_start.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen. STOP1");
                              }


                            // Anfangswerte für FOR Schleife werden festgelegt
                              Timestamp start_temp = new Timestamp(System.currentTimeMillis());
                              start_temp = start;

                              Timestamp ende_temp = new Timestamp(System.currentTimeMillis());
                              ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern
                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start_temp);
                                wh.set_ende(ende_temp);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                          if (wh.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh.get_start().getTime() >= wh.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh.get_start(), wh.get_ende(), wh.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP2");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.insert(wh_start);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start);
                                wh.set_ende(ende);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                         // Speicherung in die Datenbank
                                whMapper.insert(wh);

                    }
                    break;
                case 'w' :                                                          // bei w wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Wiederholung wh_start_w = new WiederholungImpl();
                            wh_start_w.set_kalender_id(kalender_id);
                            wh_start_w.set_start(start);
                            wh_start_w.set_ende(ende);
                            wh_start_w.set_ort(ort);
                            wh_start_w.set_beschreibung(beschreibung);
                            wh_start_w.set_kategorie(kategorie_id);
                            wh_start_w.set_erinnerung(erinnerung);
                            wh_start_w.set_erstelltvon(person_id);
                            wh_start_w.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            wh_start_w.set_wiederholung_id(highest_wh_id);
                            wh_start_w.set_serienmuster(serienmuster);
                            wh_start_w.set_anzahl(anzahl);

                            if (wh_start_w.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start_w.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start_w.get_start().getTime() >= wh_start_w.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh_start_w.get_start(), wh_start_w.get_ende(), wh_start_w.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP3");
                              }

                            start_temp = new Timestamp(System.currentTimeMillis());
                            start_temp = start;

                            ende_temp = new Timestamp(System.currentTimeMillis());
                            ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Eine Woche wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start_temp);
                                wh.set_ende(ende_temp);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                          if (wh.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh.get_start().getTime() >= wh.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh.get_start(), wh.get_ende(), wh.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP4");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.insert(wh_start_w);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start);
                                wh.set_ende(ende);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                         // Speicherung in die Datenbank
                                whMapper.insert(wh);

                    }
                     break;
                     case 'm' :                                                          // bei w wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Wiederholung wh_start_m = new WiederholungImpl();
                            wh_start_m.set_kalender_id(kalender_id);
                            wh_start_m.set_start(start);
                            wh_start_m.set_ende(ende);
                            wh_start_m.set_ort(ort);
                            wh_start_m.set_beschreibung(beschreibung);
                            wh_start_m.set_kategorie(kategorie_id);
                            wh_start_m.set_erinnerung(erinnerung);
                            wh_start_m.set_erstelltvon(person_id);
                            wh_start_m.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            wh_start_m.set_wiederholung_id(highest_wh_id);
                            wh_start_m.set_serienmuster(serienmuster);
                            wh_start_m.set_anzahl(anzahl);

                            if (wh_start_m.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start_m.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start_m.get_start().getTime() >= wh_start_m.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh_start_m.get_start(), wh_start_m.get_ende(), wh_start_m.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP5");
                              }

                            start_temp = new Timestamp(System.currentTimeMillis());
                            start_temp = start;

                            ende_temp = new Timestamp(System.currentTimeMillis());
                            ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Eine Woche wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern
                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start_temp);
                                wh.set_ende(ende_temp);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                          if (wh.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh.get_start().getTime() >= wh.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh.get_start(), wh.get_ende(), wh.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP6");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.insert(wh_start_m);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start);
                                wh.set_ende(ende);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                         // Speicherung in die Datenbank
                                whMapper.insert(wh);

                    }
                    break;
                    case 'y' :                                                          // bei w wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Wiederholung wh_start_y = new WiederholungImpl();
                            wh_start_y.set_kalender_id(kalender_id);
                            wh_start_y.set_start(start);
                            wh_start_y.set_ende(ende);
                            wh_start_y.set_ort(ort);
                            wh_start_y.set_beschreibung(beschreibung);
                            wh_start_y.set_kategorie(kategorie_id);
                            wh_start_y.set_erinnerung(erinnerung);
                            wh_start_y.set_erstelltvon(person_id);
                            wh_start_y.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            wh_start_y.set_wiederholung_id(highest_wh_id);
                            wh_start_y.set_serienmuster(serienmuster);
                            wh_start_y.set_anzahl(anzahl);

                            if (wh_start_y.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start_y.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start_y.get_start().getTime() >= wh_start_y.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh_start_y.get_start(), wh_start_y.get_ende(), wh_start_y.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP7");
                              }

                            start_temp = new Timestamp(System.currentTimeMillis());
                            start_temp = start;

                            ende_temp = new Timestamp(System.currentTimeMillis());
                            ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Eine Woche wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern
                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start_temp);
                                wh.set_ende(ende_temp);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                          if (wh.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh.get_start().getTime() >= wh.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(wh.get_start(), wh.get_ende(), wh.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP8");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.insert(wh_start_y);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Wiederholung wh = new WiederholungImpl();
                                wh.set_kalender_id(kalender_id);
                                wh.set_start(start);
                                wh.set_ende(ende);
                                wh.set_ort(ort);
                                wh.set_beschreibung(beschreibung);
                                wh.set_kategorie(kategorie_id);
                                wh.set_erinnerung(erinnerung);
                                wh.set_erstelltvon(person_id);
                                wh.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh.set_wiederholung_id(highest_wh_id);
                                wh.set_serienmuster(serienmuster);
                                wh.set_anzahl(anzahl);

                         // Speicherung in die Datenbank
                                whMapper.insert(wh);

                    }
                    break;
            }






          // Falls keine Fehler vorliegen, wird der Eintrag in der Datenbank abgespeichert
         {
              //Speichert den Kalendereintrag
            }
        }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void updateWiederholung(Wiederholung x) throws RemoteException {

                // Als erstes wird der erste Wiederholungseintrag gesucht (der Eintrag mit der niedrigsten eintrag_id)

                int lowestid = whMapper.get_lowest_eintragid_by_wh(x.get_wiederholung_id());
                System.out.println("Lowest ID: " +lowestid);
                Wiederholung wh_start = whMapper.findbyid(lowestid);
                Timestamp start_temp = new Timestamp(System.currentTimeMillis());
                start_temp = x.get_start();
                Timestamp ende_temp = new Timestamp(System.currentTimeMillis());
                ende_temp = x.get_ende();

                switch(x.get_serienmuster()){
                case 't' :                                                          // bei t wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (wh_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start.get_start().getTime() >= wh_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(x.get_start(), x.get_ende(), wh_start.get_kalender_id(), wh_start.get_eintrag_id(), x.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }


                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                          if (wh_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_temp.get_start().getTime() >= wh_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(wh_temp.get_start(), wh_temp.get_ende(), wh_temp.get_kalender_id(), wh_temp.get_eintrag_id(), wh_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.delete_by_wiederholung(x.get_wiederholung_id());
                    whMapper.insert(x);

                    start_temp = x.get_start();
                    ende_temp = x.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                         // Speicherung in die Datenbank
                                whMapper.insert(wh_temp);

                    }
                    break;
                case 'w' :                                                          // bei t wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (wh_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start.get_start().getTime() >= wh_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(x.get_start(), x.get_ende(), wh_start.get_kalender_id(), wh_start.get_eintrag_id(), x.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }



                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                          if (wh_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_temp.get_start().getTime() >= wh_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(wh_temp.get_start(), wh_temp.get_ende(), wh_temp.get_kalender_id(), wh_temp.get_eintrag_id(), wh_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden
                    whMapper.delete_by_wiederholung(x.get_wiederholung_id());
                    whMapper.insert(x);

                    start_temp = x.get_start();
                    ende_temp = x.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                         // Speicherung in die Datenbank
                                whMapper.insert(wh_temp);

                    }
                    break;
                     case 'm' :                                                          // bei m wird monatlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (wh_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start.get_start().getTime() >= wh_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(x.get_start(), x.get_ende(), wh_start.get_kalender_id(), wh_start.get_eintrag_id(), x.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }


                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                          if (wh_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_temp.get_start().getTime() >= wh_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(wh_temp.get_start(), wh_temp.get_ende(), wh_temp.get_kalender_id(), wh_temp.get_eintrag_id(), wh_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.delete_by_wiederholung(x.get_wiederholung_id());
                    whMapper.insert(x);

                    start_temp = x.get_start();
                    ende_temp = x.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                         // Speicherung in die Datenbank
                                whMapper.insert(wh_temp);

                    }
                    break;
                   case 'y' :                                                          // bei m wird monatlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (wh_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_start.get_start().getTime() >= wh_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(x.get_start(), x.get_ende(), wh_start.get_kalender_id(), wh_start.get_eintrag_id(), x.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }


                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                          if (wh_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (wh_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (wh_temp.get_start().getTime() >= wh_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(wh_temp.get_start(), wh_temp.get_ende(), wh_temp.get_kalender_id(), wh_temp.get_eintrag_id(), wh_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    whMapper.delete_by_wiederholung(x.get_wiederholung_id());
                    whMapper.insert(x);

                    start_temp = x.get_start();
                    ende_temp = x.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=x.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Wiederholung wh_temp = new WiederholungImpl();
                                wh_temp.set_kalender_id(x.get_kalender_id());
                                wh_temp.set_start(start_temp);
                                wh_temp.set_ende(ende_temp);
                                wh_temp.set_ort(x.get_ort());
                                wh_temp.set_beschreibung(x.get_beschreibung());
                                wh_temp.set_kategorie(x.get_kategorie());
                                wh_temp.set_erinnerung(x.get_erinnerung());
                                wh_temp.set_erstelltvon(x.get_erstelltvon());
                                wh_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                wh_temp.set_wiederholung_id(x.get_wiederholung_id());
                                wh_temp.set_serienmuster(x.get_serienmuster());
                                wh_temp.set_anzahl(x.get_anzahl());

                         // Speicherung in die Datenbank
                                whMapper.insert(wh_temp);

                    }
                    break;

            }



        }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteWiederholung(Wiederholung x) throws RemoteException {

            whMapper.delete_by_wiederholung(x.get_wiederholung_id());

        }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Wiederholung get_root_wiederholung(Wiederholung x) throws RemoteException {

        int lowestid = whMapper.get_lowest_eintragid_by_wh(x.get_wiederholung_id());
        return whMapper.findbyid(lowestid);

    }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteKategorie(Kategorie x) throws RemoteException {

            System.out.println("------------------deleteKategorie---------------");
            System.out.println(x.get_name());
            if(keMapper.check_kalendereintrag_exists_bykategorie(x))
                throw new RemoteException("Es existieren noch Kalender oder Kategorien. Bitte überprüfen.");
            else
                ktMapper.delete(x);


    }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteKalender(Kalender x) throws RemoteException {

            System.out.println("------------------deleteKalender---------------");
            System.out.println(x.get_bezeichnung());
            if(kaMapper.check_kalender_exists_byteilnahme(x))
                throw new RemoteException("Es existieren verknüpfungen zu Kalendereinträgen. Bitte erst diese löschen.");
            else
                kaMapper.delete(x);


    }


    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector getKalender_byPerson(Person x) throws RemoteException {

        return kaMapper.findallKalender_byPerson(x.get_person_id());

    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector getKalender_byBerechtigung(Person x) throws RemoteException {

        return kaMapper.findallKalender_byBerechtigung(x.get_person_id());

    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector <Kalendereintrag> get_kalendereintraege_by_person(Person x) throws RemoteException {

        return keMapper.findall_kalendereintraege_person(x.get_person_id());

    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector <Wiederholung> get_wiederholungen_by_person(Person x) throws RemoteException {

        return whMapper.findall_wiederholungen_person(x.get_person_id());


    }


    /**
     *
     * @param start
     * @param ende
     * @param ort
     * @param beschreibung
     * @param kategorie_id
     * @param erinnerung
     * @param person_id
     * @param eintrag_id
     * @param kalender_id
     * @param anzahl
     * @param serienmuster
     * @param eingeladene_personen
     * @throws RemoteException
     */
    public void createTermin(Timestamp start, Timestamp ende, String ort, String beschreibung, int kategorie_id, int erinnerung, int person_id, int eintrag_id, int kalender_id, int anzahl, char serienmuster, Vector <Person> eingeladene_personen) throws RemoteException {

            int highest_wh_id = whMapper.get_highest_wh_id() + 1; // es wird nach der nächsten wiederholungs_id gesucht und diese dann +1 gesetzt

            // Debug
            System.out.println("Höchste ID in der Datenbank: " + highest_wh_id);

            // Wir überprüfen das Serienmuster auf Inhalt (Bei einem normalen Kalendereintrag ohne Wiederholung, müssen keine zusätzlichen Daten berechnet und überprüft werden

            switch(serienmuster){
                case 'k' :
                            // Erster Eintrag wird auf Fehler überprüft
                            Termin te_start_k = new TerminImpl();
                            te_start_k.set_kalender_id(kalender_id);
                            te_start_k.set_start(start);
                            te_start_k.set_ende(ende);
                            te_start_k.set_ort(ort);
                            te_start_k.set_beschreibung(beschreibung);
                            te_start_k.set_kategorie(kategorie_id);
                            te_start_k.set_erinnerung(erinnerung);
                            te_start_k.set_erstelltvon(person_id);
                            te_start_k.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            te_start_k.set_wiederholung_id(0); // Stanardmäßig 0, da keine Wiederholung stattfindet
                            te_start_k.set_serienmuster(serienmuster);
                            te_start_k.set_anzahl(anzahl);
                            te_start_k.set_eingeladene_personen(eingeladene_personen);

                            if (te_start_k.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start_k.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start_k.get_start().getTime() >= te_start_k.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te_start_k.get_start(), te_start_k.get_ende(), te_start_k.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen.");
                              }


                          else {
                                // Falls kein Fehler auftritt, und alle überprüfungen in Ordnung sind, wird der Termin in die DB geschrieben
                                teMapper.insert(te_start_k);
                          }
                            break;

                case 't' :                                                          // bei t wird täglich eine Wiederholung angelegt

                            Termin te_start_t = new TerminImpl();
                            te_start_t.set_kalender_id(kalender_id);
                            te_start_t.set_start(start);
                            te_start_t.set_ende(ende);
                            te_start_t.set_ort(ort);
                            te_start_t.set_beschreibung(beschreibung);
                            te_start_t.set_kategorie(kategorie_id);
                            te_start_t.set_erinnerung(erinnerung);
                            te_start_t.set_erstelltvon(person_id);
                            te_start_t.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            te_start_t.set_wiederholung_id(highest_wh_id); // Stanardmäßig 0, da keine Wiederholung stattfindet
                            te_start_t.set_serienmuster(serienmuster);
                            te_start_t.set_anzahl(anzahl);
                            te_start_t.set_eingeladene_personen(eingeladene_personen);

                            if (te_start_t.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start_t.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start_t.get_start().getTime() >= te_start_t.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te_start_t.get_start(), te_start_t.get_ende(), te_start_t.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen. STOP1");
                              }


                            // Anfangswerte für FOR Schleife werden festgelegt
                              Timestamp start_temp = new Timestamp(System.currentTimeMillis());
                              start_temp = start;

                              Timestamp ende_temp = new Timestamp(System.currentTimeMillis());
                              ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern
                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start_temp);
                                te.set_ende(ende_temp);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                          if (te.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te.get_start().getTime() >= te.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te.get_start(), te.get_ende(), te.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen.");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.insert(te_start_t);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start);
                                te.set_ende(ende);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                         // Speicherung in die Datenbank
                                teMapper.insert(te);

                    }
                    break;
                case 'w' :                                                          // bei w wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Termin te_start_w = new TerminImpl();
                            te_start_w.set_kalender_id(kalender_id);
                            te_start_w.set_start(start);
                            te_start_w.set_ende(ende);
                            te_start_w.set_ort(ort);
                            te_start_w.set_beschreibung(beschreibung);
                            te_start_w.set_kategorie(kategorie_id);
                            te_start_w.set_erinnerung(erinnerung);
                            te_start_w.set_erstelltvon(person_id);
                            te_start_w.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            te_start_w.set_wiederholung_id(highest_wh_id); // Stanardmäßig 0, da keine Wiederholung stattfindet
                            te_start_w.set_serienmuster(serienmuster);
                            te_start_w.set_anzahl(anzahl);
                            te_start_w.set_eingeladene_personen(eingeladene_personen);

                            if (te_start_w.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start_w.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start_w.get_start().getTime() >= te_start_w.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te_start_w.get_start(), te_start_w.get_ende(), te_start_w.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP3");
                              }

                            start_temp = new Timestamp(System.currentTimeMillis());
                            start_temp = start;

                            ende_temp = new Timestamp(System.currentTimeMillis());
                            ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Eine Woche wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start_temp);
                                te.set_ende(ende_temp);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                          if (te.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te.get_start().getTime() >= te.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te.get_start(), te.get_ende(), te.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen.");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.insert(te_start_w);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start);
                                te.set_ende(ende);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                         // Speicherung in die Datenbank
                                teMapper.insert(te);

                    }
                     break;
                     case 'm' :                                                          // bei m wird monatlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Termin te_start_m = new TerminImpl();
                            te_start_m.set_kalender_id(kalender_id);
                            te_start_m.set_start(start);
                            te_start_m.set_ende(ende);
                            te_start_m.set_ort(ort);
                            te_start_m.set_beschreibung(beschreibung);
                            te_start_m.set_kategorie(kategorie_id);
                            te_start_m.set_erinnerung(erinnerung);
                            te_start_m.set_erstelltvon(person_id);
                            te_start_m.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            te_start_m.set_wiederholung_id(highest_wh_id); // Stanardmäßig 0, da keine Wiederholung stattfindet
                            te_start_m.set_serienmuster(serienmuster);
                            te_start_m.set_anzahl(anzahl);
                            te_start_m.set_eingeladene_personen(eingeladene_personen);

                            if (te_start_m.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start_m.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start_m.get_start().getTime() >= te_start_m.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te_start_m.get_start(), te_start_m.get_ende(), te_start_m.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen.");
                              }

                            start_temp = new Timestamp(System.currentTimeMillis());
                            start_temp = start;

                            ende_temp = new Timestamp(System.currentTimeMillis());
                            ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Eine Woche wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern
                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start_temp);
                                te.set_ende(ende_temp);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                          if (te.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te.get_start().getTime() >= te.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te.get_start(), te.get_ende(), te.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen.");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.insert(te_start_m);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start);
                                te.set_ende(ende);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                         // Speicherung in die Datenbank
                                teMapper.insert(te);

                    }
                    break;
                    case 'y' :                                                          // bei y wird jährlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft
                            Termin te_start_y = new TerminImpl();
                            te_start_y.set_kalender_id(kalender_id);
                            te_start_y.set_start(start);
                            te_start_y.set_ende(ende);
                            te_start_y.set_ort(ort);
                            te_start_y.set_beschreibung(beschreibung);
                            te_start_y.set_kategorie(kategorie_id);
                            te_start_y.set_erinnerung(erinnerung);
                            te_start_y.set_erstelltvon(person_id);
                            te_start_y.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                            te_start_y.set_wiederholung_id(highest_wh_id); // Stanardmäßig 0, da keine Wiederholung stattfindet
                            te_start_y.set_serienmuster(serienmuster);
                            te_start_y.set_anzahl(anzahl);
                            te_start_y.set_eingeladene_personen(eingeladene_personen);

                            if (te_start_y.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start_y.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start_y.get_start().getTime() >= te_start_y.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te_start_y.get_start(), te_start_y.get_ende(), te_start_y.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen STOP7");
                              }

                            start_temp = new Timestamp(System.currentTimeMillis());
                            start_temp = start;

                            ende_temp = new Timestamp(System.currentTimeMillis());
                            ende_temp = ende;

                    for(int i=1; i<=anzahl; i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Eine Woche wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern
                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start_temp);
                                te.set_ende(ende_temp);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                          if (te.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te.get_start().getTime() >= te.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (keMapper.check_datum_available(te.get_start(), te.get_ende(), te.get_kalender_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen.");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.insert(te_start_y);

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=anzahl; i++)
                    {
                        //Startdatum editieren

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            start = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start);

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende);

                                Termin te = new TerminImpl();
                                te.set_kalender_id(kalender_id);
                                te.set_start(start);
                                te.set_ende(ende);
                                te.set_ort(ort);
                                te.set_beschreibung(beschreibung);
                                te.set_kategorie(kategorie_id);
                                te.set_erinnerung(erinnerung);
                                te.set_erstelltvon(person_id);
                                te.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te.set_wiederholung_id(highest_wh_id);
                                te.set_serienmuster(serienmuster);
                                te.set_anzahl(anzahl);
                                te.set_eingeladene_personen(eingeladene_personen);

                         // Speicherung in die Datenbank
                                teMapper.insert(te);

                    }
                    break;
            }






          // Falls keine Fehler vorliegen, wird der Eintrag in der Datenbank abgespeichert
         {
              //Speichert den Kalendereintrag
            }
        }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector <Termin> get_termine_by_person(Person x) throws RemoteException {

        return teMapper.findall_termine_person(x.get_person_id());

    }

    /**
     *
     * @param editierter_eintrag
     * @throws RemoteException
     */
    public void updateTermin(Termin editierter_eintrag) throws RemoteException {

            // Überprüfung ob Ort ausgefüllt wurde
                  if (editierter_eintrag.get_ort().isEmpty())
                  throw new RemoteException("Bitte Ort überprüfen.");

                  // Überprüfung ob Beschreibung ausgefüllt wurde
                  else if (editierter_eintrag.get_beschreibung().isEmpty())
                  throw new RemoteException("Bitte Beschreibung überprüfen.");

                  // Überprüfung ob START Datum vor END Datum liegt
                  else if (editierter_eintrag.get_start().getTime() >= editierter_eintrag.get_ende().getTime())
                  throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");

                  // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                  else if (keMapper.check_datum_available_at_update(editierter_eintrag.get_start(), editierter_eintrag.get_ende(), editierter_eintrag.get_kalender_id(), editierter_eintrag.get_eintrag_id()))
                  throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");

          // Falls keine Fehler vorliegen, wird der Eintrag in der Datenbank abgespeichert
          else {
             teMapper.update(editierter_eintrag); //Speichert den Kalendereintrag
            }
        }

    /**
     *
     * @param eingeloggte_person
     * @return
     * @throws RemoteException
     */
    public Vector<Termin> get_wiederholung_termine_by_person(Person eingeloggte_person) throws RemoteException {
                return teMapper.findall_wiederholungen_termine_person(eingeloggte_person.get_person_id());
            }

    /**
     *
     * @param editierter_eintrag
     * @throws RemoteException
     */
    public void updateTermin_wiederholung(Termin editierter_eintrag) throws RemoteException {

                // Als erstes wird der erste Wiederholungseintrag gesucht (der Eintrag mit der niedrigsten eintrag_id)

                int lowestid = whMapper.get_lowest_eintragid_by_wh(editierter_eintrag.get_wiederholung_id());
                System.out.println("Lowest ID: " +lowestid);
                Termin te_start = editierter_eintrag; // Der editierter_eintrag liefert schon den Termin mit der kleinsten Eintrags_ID
                Timestamp start_temp = new Timestamp(System.currentTimeMillis());
                start_temp = editierter_eintrag.get_start();
                Timestamp ende_temp = new Timestamp(System.currentTimeMillis());
                ende_temp = editierter_eintrag.get_ende();

                switch(editierter_eintrag.get_serienmuster()){
                case 't' :                                                          // bei t wird täglich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (te_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start.get_start().getTime() >= te_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(te_start.get_start(), te_start.get_ende(), te_start.get_kalender_id(), te_start.get_eintrag_id(), te_start.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }


                    for(int i=1; i<=te_start.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(te_start.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(te_start.get_ort());
                                te_temp.set_beschreibung(te_start.get_beschreibung());
                                te_temp.set_kategorie(te_start.get_kategorie());
                                te_temp.set_erinnerung(te_start.get_erinnerung());
                                te_temp.set_erstelltvon(te_start.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(te_start.get_wiederholung_id());
                                te_temp.set_serienmuster(te_start.get_serienmuster());
                                te_temp.set_anzahl(te_start.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                          if (te_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_temp.get_start().getTime() >= te_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(te_temp.get_start(), te_temp.get_ende(), te_temp.get_kalender_id(), te_temp.get_eintrag_id(), te_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.delete_by_wiederholung(editierter_eintrag.get_wiederholung_id());
                    teMapper.insert(editierter_eintrag);

                    start_temp = editierter_eintrag.get_start();
                    ende_temp = editierter_eintrag.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.DAY_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                         // Speicherung in die Datenbank
                                teMapper.insert(te_temp);

                    }
                    break;
                case 'w' :                                                          // bei w wird wöchentlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (te_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start.get_start().getTime() >= te_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(te_start.get_start(), te_start.get_ende(), te_start.get_kalender_id(), te_start.get_eintrag_id(), te_start.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }



                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                          if (te_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_temp.get_start().getTime() >= te_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(te_temp.get_start(), te_temp.get_ende(), te_temp.get_kalender_id(), te_temp.get_eintrag_id(), te_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden
                    teMapper.delete_by_wiederholung(editierter_eintrag.get_wiederholung_id());
                    whMapper.insert(editierter_eintrag);

                    start_temp = editierter_eintrag.get_start();
                    ende_temp = editierter_eintrag.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.WEEK_OF_MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                         // Speicherung in die Datenbank
                                teMapper.insert(te_temp);

                    }
                    break;
                     case 'm' :                                                          // bei m wird monatlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (te_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start.get_start().getTime() >= te_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(te_start.get_start(), te_start.get_ende(), te_start.get_kalender_id(), te_start.get_eintrag_id(), te_start.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }


                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                          if (te_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_temp.get_start().getTime() >= te_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(te_temp.get_start(), te_temp.get_ende(), te_temp.get_kalender_id(), te_temp.get_eintrag_id(), te_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.delete_by_wiederholung(editierter_eintrag.get_wiederholung_id());
                    teMapper.insert(editierter_eintrag);

                    start_temp = editierter_eintrag.get_start();
                    ende_temp = editierter_eintrag.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.MONTH, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                         // Speicherung in die Datenbank
                                teMapper.insert(te_temp);

                    }
                    break;
                   case 'y' :                                                          // bei m wird monatlich eine Wiederholung angelegt

                            // Erster Eintrag wird auf Fehler überprüft

                            if (te_start.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_start.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_start.get_start().getTime() >= te_start.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt (Nur Kalendereintrag)
                          else if (whMapper.check_datum_available_at_update_wh(te_start.get_start(), te_start.get_ende(), te_start.get_kalender_id(), te_start.get_eintrag_id(), te_start.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }


                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                            //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                          if (te_temp.get_ort().isEmpty())
                              {
                              throw new RemoteException("Bitte Ort überprüfen.");
                              }

                          // Überprüfung ob Beschreibung ausgefüllt wurde
                          else if (te_temp.get_beschreibung().isEmpty())
                              {
                              throw new RemoteException("Bitte Beschreibung überprüfen.");
                              }

                          // Überprüfung ob START Datum vor END Datum liegt
                          else if (te_temp.get_start().getTime() >= te_temp.get_ende().getTime())
                              {
                              throw new RemoteException("Enddatum liegt vor Startdatum. Bitte überprüfen.");
                              }

                          // Überprüfung Überschneidung vorliegt
                          else if (whMapper.check_datum_available_at_update_wh(te_temp.get_start(), te_temp.get_ende(), te_temp.get_kalender_id(), te_temp.get_eintrag_id(), te_temp.get_wiederholung_id()))
                              {
                              throw new RemoteException("Eintrag überschneidet sich. Bitte überpüfen");
                              }

                    }

                    // Falls die oberen Schleifen ohne exeption durchläuft wird der erste Eintrag in der Datenbank gespeichert werden

                    teMapper.delete_by_wiederholung(editierter_eintrag.get_wiederholung_id());
                    whMapper.insert(editierter_eintrag);

                    start_temp = editierter_eintrag.get_start();
                    ende_temp = editierter_eintrag.get_ende();

                    // Falls die oberen Schleifen ohne exeption durchläuft werden die Wiederholungseinträge in der Datenbank gespeichert werden
                    for(int i=1; i<=editierter_eintrag.get_anzahl(); i++)
                    {
                        //Startdatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit STARTDATUM
                            Calendar cal_start=GregorianCalendar.getInstance();
                            cal_start.setTime(start_temp);
                            cal_start.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_start.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_start.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            start_temp = new Timestamp(cal_start.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Startdatum: " + start_temp);

                            //Enddatum editieren, temporären Timestamp anlegen ohne den Originaltimestamp zu ändern

                            // Umwandlung von Timestamp in Gregorian Calender + Berechnung von neuem Datum/Uhrzeit ENDDATUM
                            Calendar cal_ende=GregorianCalendar.getInstance();
                            cal_ende.setTime(ende_temp);
                            cal_ende.set(Calendar.MILLISECOND, 0);                 // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Milisekunden
                            cal_ende.set(Calendar.SECOND, 0);                      // Wird manuell auf 0 gesetzt, da die Methode getInstance() die aktuelle Uhrzeit generiert samt Sekunden
                            cal_ende.add(Calendar.YEAR, 1);                // Ein Tag wird hinzugefügt
                            ende_temp = new Timestamp(cal_ende.getTimeInMillis());     // Umwandlung in Timestamp

                            System.out.println(i + ". Endedatum: " + ende_temp);

                                Termin te_temp = new TerminImpl();
                                te_temp.set_kalender_id(editierter_eintrag.get_kalender_id());
                                te_temp.set_start(start_temp);
                                te_temp.set_ende(ende_temp);
                                te_temp.set_ort(editierter_eintrag.get_ort());
                                te_temp.set_beschreibung(editierter_eintrag.get_beschreibung());
                                te_temp.set_kategorie(editierter_eintrag.get_kategorie());
                                te_temp.set_erinnerung(editierter_eintrag.get_erinnerung());
                                te_temp.set_erstelltvon(editierter_eintrag.get_erstelltvon());
                                te_temp.set_eintrag_id(2); // wird überschrieben wenn Datenbank schreibt
                                te_temp.set_wiederholung_id(editierter_eintrag.get_wiederholung_id());
                                te_temp.set_serienmuster(editierter_eintrag.get_serienmuster());
                                te_temp.set_anzahl(editierter_eintrag.get_anzahl());
                                te_temp.set_eingeladene_personen(editierter_eintrag.get_eingeladene_personen());

                         // Speicherung in die Datenbank
                                teMapper.insert(te_temp);

                    }
                    break;

            }



        }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteTermin(Termin x) throws RemoteException
    {
        teMapper.delete(x); //Löscht den Termin samt Teilnehmer
    }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteTermin_Wiederholung(Termin x) throws RemoteException {
        teMapper.delete_wiederholung(x); //Löscht den Termin samt Teilnehmer
    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector <Kalendereintrag> find_all_einladungen_by_person(Person x) throws RemoteException {

        return keMapper.find_all_einladungen_by_person(x.get_person_id()); //Liest alle offenen Einladungen aus
    }

    /**
     *
     * @param x
     * @param y
     * @param z
     * @throws RemoteException
     */
    public void zuweisung_Kalender_Teilnahme(Kalendereintrag x, Kalender y, Person z) throws RemoteException {
        keMapper.zuweisung_Kalender_Teilnahme(x,y,z);
    }

    /**
     *
     * @param eingeloggte_person
     * @param selektierte_person
     * @return
     * @throws RemoteException
     */
    public Vector <Kalender> get_kalender_reporter(Person eingeloggte_person, Person selektierte_person) throws RemoteException {

        // Auslesen der Kalender der selektierten Person
        Vector <Kalender> x = new Vector();
        x = getKalender_byPerson(selektierte_person);

        return kaMapper.get_kalender_reporter(eingeloggte_person, x);
    }

    /**
     *
     * @param x
     * @param y
     * @param sta
     * @param end
     * @return
     * @throws RemoteException
     */
    public Vector <Kalendereintrag> ausgabe_reporter(Kalender x, Kategorie y, Timestamp sta, Timestamp end) throws RemoteException {
           return keMapper.get_ausgabe_reporter(x,y,sta,end);
    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Alarm createAlarm(Alarm x) throws RemoteException {
        return alMapper.insert(x);
    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Alarm updateAlarm(Alarm x) throws RemoteException {
        return alMapper.update(x);
    }

    /**
     *
     * @param x
     * @throws RemoteException
     */
    public void deleteAlarm(Alarm x) throws RemoteException {
        alMapper.delete(x);
    }

    /**
     *
     * @param x
     * @return
     * @throws RemoteException
     */
    public Vector <Alarm> findall_alarm_by_person(int x) throws RemoteException {
         return alMapper.findall_alarm_by_person(x);
     }


}

